package jrain.utils.sql;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import jrain.utils.collection.CollectionUtils;
import jrain.utils.lang.StringUtils;

/**
 * <pre>
 * 作者：489088214@qq.com 
 * 描述： SQL处理工具类
 * </pre>
 */
public class SqlUtils {
	/**
	 * 获取执行sql
	 * @param sql SQL语句
	 * @param list 参数
	 * @return sql 执行sql
	 */
	public static String calculationSql(String sql, List<Object> list) {
		if (list == null) {
			list = new ArrayList<Object>(0);
		}
		return calculationSql(sql, list.toArray());
	}

	/**
	 * 获取执行SQL
	 * @param sql SQL
	 * @param params 参数
	 * @return SQL 执行SQL
	 */
	public static String calculationSql(String sql, Object[] params) {
		int paramNum = 0;
		if (params != null) {
			paramNum = params.length;
		}
		if (paramNum == 0) {
			return sql;
		}
		StringBuffer returnSQL = new StringBuffer();
		String[] subSQL = sql.split("\\?");
		for (int i = 0; i < paramNum && i < subSQL.length; i++) {
			if (params[i] instanceof String) {
				returnSQL.append(subSQL[i]).append(" '").append(params[i]).append("' ");
			} else {
				returnSQL.append(subSQL[i]).append(params[i]);
			}
		}
		if (subSQL.length > params.length) {
			returnSQL.append(subSQL[subSQL.length - 1]);
		}
		return returnSQL.toString();
	}

	// -------------------------------------------------------------------------------------------------
	/**
	 * 创建预处理语句段
	 * @param num 个数
	 * @return 预处理语句段
	 */
	public static String createPrepared(int num) {
		StringBuffer sb = new StringBuffer(num * 2 + 10);
		for (int i = 0; i < num; i++) {
			sb.append("?,");
		}
		sb.deleteCharAt(sb.lastIndexOf(","));
		return sb.toString();
	}

	/**
	 * 创建预处理语句段
	 * @param fieldName 字段名称
	 * @param num 个数
	 * @return 创建预处理语句段
	 */
	public static String createInPrepared(String fieldName, int num) {
		return createInPrepared(fieldName, num, true);
	}

	/**
	 * 创建预处理语句段
	 * @param fieldName 字段名称
	 * @param num 个数
	 * @param b 是否包含where
	 * @return 预处理语句段
	 */
	public static String createInPrepared(String fieldName, int num, boolean b) {
		StringBuffer sb = new StringBuffer(num * 2 + 40);
		sb.append(b ? " WHERE " : "");
		sb.append(fieldName).append(" IN(");
		sb.append(createPrepared(num));
		sb.append(")");
		return sb.toString();
	}

	/**
	 * 获取字段IN的条件
	 * @param list 条件列表
	 * @param fieldName 字段名称
	 * @return 字段IN的条件
	 */
	public static String createInCondition(List<?> list, String fieldName) {
		return createInCondition(list, fieldName, true);
	}

	/**
	 * 获取字段IN的条件
	 * @param list 条件列表
	 * @param fieldName 字段名称
	 * @param b 生成WHERE
	 * @return 字段IN的条件
	 */
	public static String createInCondition(Collection<?> list, String fieldName, boolean b) {
		if (list == null || list.size() == 0)
			return "";
		StringBuffer sb = new StringBuffer(list.size() * 8);
		sb.append(b ? " WHERE " : "");
		if (list.size() == 1) {
			sb.append(fieldName).append(" = ");
		} else {
			sb.append(fieldName).append(" IN(");
		}
		for (Object object : list) {
			if (object instanceof Number) {
				sb.append(String.valueOf(object));
			} else {
				sb.append("'");
				sb.append(object.toString());
				sb.append("'");
			}
			sb.append(",");
		}
		sb.deleteCharAt(sb.lastIndexOf(","));
		if (list.size() > 1) {
			sb.append(")");
		}
		return sb.toString();
	}

	// -------------------------------------------------------------------------------------------------
	/**
	 * 将列名转换为字段名
	 * @param columnName 列名称
	 * @return 字段名
	 */
	public static String columnToField(String columnName) {
		return StringUtils.columnToField(columnName);
	}

	/**
	 * 字段名转换为列名
	 * @param fieldName 字段名
	 * @return 列名称
	 */
	public static String fieldToColumn(String fieldName) {
		return StringUtils.fieldToColumn(fieldName);
	}
	// -------------------------------------------------------------------------------------------------

	/**
	 * 添加查询条件 等于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionEquals(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_1", value);
	}

	/**
	 * 添加查询条件 不等于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionNotEquals(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_2", value);
	}

	/**
	 * 添加查询条件 大于等于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionGreaterThan(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_3", value);
	}

	/**
	 * 添加查询条件 大于等于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionGreaterThanEquals(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_4", value);
	}

	/**
	 * 添加查询条件 小于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionLessThan(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_5", value);
	}

	/**
	 * 添加查询条件 小于等于
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionLessThanEquals(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_6", value);
	}

	/**
	 * 添加查询条件 LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_7", value);
	}

	/**
	 * 添加查询条件 NOT LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionNotLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_8", value);
	}

	/**
	 * 添加查询条件 LEFT LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionLeftLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_9", value);
	}

	/**
	 * 添加查询条件 NOT LEFT LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionNotLeftLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_10", value);
	}

	/**
	 * 添加查询条件 RIGHT LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionRightLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_11", value);
	}

	/**
	 * 添加查询条件 NOT RIGHT LIKE
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionNotRightLike(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_12", value);
	}

	/**
	 * 添加查询条件IN
	 * @param paramMap 参数
	 * @param key 键
	 * @param value 值
	 */
	public static void addConditionIn(Map<String, Object> paramMap, String key, Object value) {
		paramMap.put("c_" + key + "_99", value);
	}

	/**
	 * LIKE处理
	 * @param param 参数
	 * @return LIKE字符串
	 */
	public static String likeTrim(String param) {
		return "%" + StringUtils.trimNull(param) + "%";
	}

	/**
	 * LLIKE处理
	 * @param param 参数
	 * @return LIKE字符串
	 */
	public static String likeLTrim(String param) {
		return "%" + StringUtils.trimNull(param);
	}

	/**
	 * RLIKE处理
	 * @param param 参数
	 * @return LIKE字符串
	 */
	public static String likeRTrim(String param) {
		return StringUtils.trimNull(param) + "%";
	}

	// -------------------------------------------------------------------------------------------------
	/**
	 * 动态的生成查询条件和参数
	 * @param columnCode 列编号
	 * @param op 操作
	 * @param value 值
	 * @param conditionSql 条件SQL
	 * @param rsList 参数数值列表
	 */
	public static void parseQueryCondition(String columnCode, String op, Object value, StringBuffer conditionSql, List<Object> rsList) {
		parseQueryCondition(columnCode, op, value, conditionSql, rsList, 1);
	}

	/**
	 * 动态的生成查询条件和参数
	 * 
	 * <pre>
	 * 	1=等于
	 *  2=不等于
	 *  3=大于
	 *  4=大于等于
	 *  5=小于
	 *  6=小于等于
	 *  7=LIKE
	 *  8=NOT LIKE
	 *  9=LEFT LIKE
	 *  10=NOT LEFT LIKE
	 *  11=RIGHT LIKE
	 *  12=NOT RIGHT LIKE
	 * </pre>
	 * 
	 * @param columnCode 列编号
	 * @param op 操作
	 * @param value 值
	 * @param conditionSql 条件SQL
	 * @param rsList 参数数值列表
	 * @param andOr 1=AND 2=OR
	 */
	public static void parseQueryCondition(String columnCode, String op, Object value, StringBuffer conditionSql, List<Object> rsList, int andOr) {
		if (andOr == 1) {
			conditionSql.append(" AND ");
		} else if (andOr == 2) {
			conditionSql.append(" OR ");
		}
		if (!"99".equals(op)) {
			conditionSql.append(columnCode);
		}
		if ("1".equals(op)) {
			conditionSql.append(" = ? ");
			rsList.add(value);
		} else if ("2".equals(op)) {
			conditionSql.append(" <> ? ");
			rsList.add(value);
		} else if ("3".equals(op)) {
			conditionSql.append(" > ?");
			rsList.add(value);
		} else if ("4".equals(op)) {
			conditionSql.append(" >= ? ");
			rsList.add(value);
		} else if ("5".equals(op)) {
			conditionSql.append(" < ?");
			rsList.add(value);
		} else if ("6".equals(op)) {
			conditionSql.append(" <= ? ");
			rsList.add(value);
		} else if ("7".equals(op)) {
			conditionSql.append(" LIKE ?");
			rsList.add(likeTrim((String) value));
		} else if ("8".equals(op)) {
			conditionSql.append(" NOT LIKE ?");
			rsList.add(likeTrim((String) value));
		} else if ("9".equals(op)) {
			conditionSql.append(" LIKE ?");
			rsList.add(likeLTrim((String) value));
		} else if ("10".equals(op)) {
			conditionSql.append(" NOT LIKE ");
			rsList.add(likeLTrim((String) value));
		} else if ("11".equals(op)) {
			conditionSql.append(" LIKE ? ");
			rsList.add(likeRTrim((String) value));
		} else if ("12".equals(op)) {
			conditionSql.append(" NOT LIKE ?");
			rsList.add(likeRTrim((String) value));
		} else if ("99".equals(op)) {
			List<?> values = new ArrayList<String>();
			if (value instanceof List) {
				values = (List<?>) value;
			} else {
				values = CollectionUtils.valueOfList((String) value);
			}
			if (values.size() > 0) {
				conditionSql.append(columnCode);
				conditionSql.append(" IN (");
				conditionSql.append(SqlUtils.createPrepared(values.size()));
				conditionSql.append(')');
				rsList.addAll(values);
			}
		}
	}

	// -------------------------------------------------------------------------------------------------
	/**
	 * 关闭结果集
	 * @param rs 结果集
	 */
	public static void closeRs(ResultSet rs) {
		try {
			if (rs != null) {
				rs.close();
			}
		} catch (Exception e) {
		}
	}

	/**
	 * 关闭PSTMT
	 * @param pstmt 预处理
	 */
	public static void closeStmt(PreparedStatement pstmt) {
		try {
			if (pstmt != null) {
				pstmt.close();
			}
		} catch (SQLException e1) {
		}
	}

	/**
	 * 关闭连接
	 * @param conn 连接
	 */
	public static void closeConn(Connection conn) {
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e1) {
		}
	}

	/**
	 * 提交事务
	 * @param conn 连接
	 */
	public static void commit(Connection conn) {
		try {
			if (conn != null) {
				conn.commit();
			}
		} catch (SQLException e1) {
		}
	}

	/**
	 * 回滚事务
	 * @param conn 连接
	 */
	public static void rollback(Connection conn) {
		try {
			if (conn != null) {
				conn.rollback();
			}
		} catch (SQLException e1) {
		}
	}

	/**
	 * 设置是否自动提交
	 * @param conn 连接
	 * @param b 是否自动提交
	 */
	public static void setAutoCommit(Connection conn, boolean b) {
		try {
			if (conn != null) {
				conn.setAutoCommit(b);
			}
		} catch (SQLException e1) {
		}
	}
}
